import { Template, StoredTemplates, DocumentParams } from '@/types';

// 本地存储键名
const TEMPLATE_STORAGE_KEY = 'document_templates';

/**
 * 获取默认模板
 */
export const getDefaultTemplates = (): StoredTemplates => {
  return {
    "template1": {
      "title": "征收决定公告",
      "fields": {
        "文号": "",
        "日期": "",
        "征收单位": "",
        "项目名称": "",
        "征收范围": "",
        "补偿标准": ""
      },
      "content": "根据《国有土地上房屋征收与补偿条例》规定，{{征收单位}}决定对{{项目名称}}项目范围内的房屋实施征收。征收范围为{{征收范围}}。补偿标准按照{{补偿标准}}执行。"
    }
  };
};

/**
 * 初始化模板存储
 */
export const initializeTemplateStorage = (): void => {
  if (!localStorage.getItem(TEMPLATE_STORAGE_KEY)) {
    const defaultTemplates = getDefaultTemplates();
    localStorage.setItem(TEMPLATE_STORAGE_KEY, JSON.stringify(defaultTemplates));
  }
};

/**
 * 加载所有模板
 */
export const loadTemplates = (): Template[] => {
  initializeTemplateStorage();
  
  const storedTemplates = localStorage.getItem(TEMPLATE_STORAGE_KEY);
  if (!storedTemplates) return [];
  
  const templatesData = JSON.parse(storedTemplates) as StoredTemplates;
  
  return Object.entries(templatesData).map(([id, data]) => ({
    id,
    title: data.title,
    params: Object.keys(data.fields).map(key => ({
      name: key,
      label: key,
      type: 'text'
    })),
    content: data.content
  }));
};

/**
 * 保存所有模板
 */
export const saveTemplates = (templates: Template[]): void => {
  const templatesData: StoredTemplates = {};
  
  templates.forEach(template => {
    templatesData[template.id] = {
      title: template.title,
      fields: template.params.reduce((acc, param) => {
        acc[param.name] = "";
        return acc;
      }, {} as Record<string, string>),
      content: template.content
    };
  });
  
  localStorage.setItem(TEMPLATE_STORAGE_KEY, JSON.stringify(templatesData));
};

/**
 * 添加新模板
 */
export const addTemplate = (template: Omit<Template, 'id'>): Template => {
  const templates = loadTemplates();
  const newTemplate: Template = {
    ...template,
    id: `template${Date.now()}`
  };
  
  const updatedTemplates = [...templates, newTemplate];
  saveTemplates(updatedTemplates);
  
  return newTemplate;
};

/**
 * 更新模板
 */
export const updateTemplate = (updatedTemplate: Template): void => {
  const templates = loadTemplates();
  const updatedTemplates = templates.map(template => 
    template.id === updatedTemplate.id ? updatedTemplate : template
  );
  
  saveTemplates(updatedTemplates);
};

/**
 * 删除模板
 */
export const deleteTemplate = (templateId: string): void => {
  const templates = loadTemplates();
  const updatedTemplates = templates.filter(template => template.id !== templateId);
  
  saveTemplates(updatedTemplates);
};

/**
 * 导入模板
 */
export const importTemplates = (templatesData: StoredTemplates): void => {
  // 获取现有模板
  const existingTemplates = loadTemplates();
  const existingTemplateIds = new Set(existingTemplates.map(t => t.id));
  
  // 生成新模板ID，避免与现有模板冲突
  const newTemplates: StoredTemplates = {};
  
  // 处理导入的模板
  Object.entries(templatesData).forEach(([id, templateData]) => {
    // 如果ID已存在，生成新的唯一ID
    let newId = id;
    while (existingTemplateIds.has(newId)) {
      newId = `imported_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
    }
    
    newTemplates[newId] = templateData;
    existingTemplateIds.add(newId); // 添加到已存在ID集合，防止重复
  });
  
  // 获取当前存储的所有模板
  const currentStorage = JSON.parse(localStorage.getItem(TEMPLATE_STORAGE_KEY) || '{}');
  
  // 合并现有模板和新导入的模板
  const mergedTemplates = { ...currentStorage, ...newTemplates };
  
  // 保存合并后的模板
  localStorage.setItem(TEMPLATE_STORAGE_KEY, JSON.stringify(mergedTemplates));
};

/**
 * 生成文档内容
 */
export const generateDocumentContent = (template: Template, params: DocumentParams): string => {
  let content = template.content;
  
  // 替换所有占位符
  Object.entries(params).forEach(([key, value]) => {
    const placeholder = `{{${key}}}`;
    content = content.replace(new RegExp(placeholder, 'g'), value || `【缺失参数 ${key}】`);
  });
  
  return content;
};